/**
请实现一个Mini订货系统，提供订货、发货、查询功能：
OrderSystem() — 系统初始化。
order(int customerId, string[] goods) — 表示某客户的一次订货，goods每个元素表示一件商品，值为商品种类：
同一客户可以多次订货；单次订货，可对同一种类的商品订购多件。

deliver(string[] goods) — 表示发货多件商品，goods含义同上：每个元素表示一件商品，值为商品种类
依次将每件商品按照订购的先后顺序发给订购这件商品的客户
注：用例保证发的商品一定被某客户订购过。

query() — 查询并返回系统中未发货件数最大的客户Id；若存在并列，返回客户Id较小的；若所有客户都完成发货，返回 -1 。

输入样例:
OrderSystem()
order(99, ["gd1000"])
order(88, ["gd666", "gd555"])
order(99, ["gd666"])
query()
deliver(["gd666"])
query()
输出样例:
null
null
null
null
88
null
99
提示样例 1
第一次 query 时，客户99 和 客户88 的未发货件数都是 2，返回客户id较小的 88 。
客户88 先订货商品 gd666，所以 deliver([“gd666”]) 发货给客户88。第二次 query 时，客户88 和 客户99 的未发货件数分别为 1 和 2，因此返回 99 。
*/
class OrderSystem {
  /**
   * @return { void }
   */
  constructor() {
    this.orderList = [];
    this.goodsedList = [];
  }

  /**
   * @param { number } customerId
   * @param { string[] } goods
   * @return { void }
   */
  order = (customerId, goods) => {
    for (const i of goods) {
      this.goodsedList.push({
        good: i,
        customerId,
      });
    }

    if (this.orderList.findIndex((i) => i?.[0] === customerId) === -1) {
      this.orderList.push([customerId, goods]);
    } else {
      for (const [customer, goodsList] of this.orderList) {
        if (customerId === customer) {
          goodsList.push(...goods);
        }
      }
    }
    return null;
  };

  /**
   * @param { string[] } goods
   * @return { void }
   */
  deliver = (goods) => {
    let _index = -1;
    for (const good of goods) {
      _index = this.goodsedList.findIndex((i) => i.good === good);

      if (_index !== -1) {
        this.orderList.forEach((item) => {
          if (item[0] === this.goodsedList[_index].customerId) {
            item[1].splice(item[1].indexOf(good), 1);
          }
        });
        this.goodsedList.splice(_index, 1);
      }
    }

    return null;
  };

  /**
   * @return { number }
   */
  query = () => {
    const arr = this.orderList.filter((i) => i[1].length);
    if (arr.length < 1) {
      return -1;
    }
    arr.sort((a, b) => b[1].length - a[1].length);
    const filterArr = arr.filter((item) => item[1].length === arr[0][1].length);
    const res = Math.min(...filterArr.map((i) => i[0]));
    return res;
  };
}
